/**
 * File Name:    FileUtils.java
 *
 * File Desc:    
 *
 * Product AB:   
 *
 * Product Name: 
 *
 * Module Name:  
 *
 * Module AB:    
 *
 * Author:       夏绪宏
 *
 * History:      14-8-5 created by 夏绪宏
 */
package com.dalgen.mybatis.utils;

import java.io.*;
import java.util.*;

/**
 * @author xh.xia
 * @version 1.0
 */
public class FileUtils
{
    private static String message;

    public FileUtils()
    {
    }

    /**
     * 读取文本文件内容
     *
     * @param filePathAndName 带有完整绝对路径的文件名
     * @param encoding        文本文件打开的编码方式
     * @return 返回文本文件的内容
     */
    public static String readTxt( String filePathAndName, String encoding )
    {
        encoding = encoding.trim();
        StringBuffer str = new StringBuffer( "" );
        String st = "";
        try
        {
            FileInputStream fs = new FileInputStream( filePathAndName );
            InputStreamReader isr;
            if ( encoding.equals( "" ) )
            {
                isr = new InputStreamReader( fs );
            } else
            {
                isr = new InputStreamReader( fs, encoding );
            }
            BufferedReader br = new BufferedReader( isr );
            try
            {
                String data = "";
                while ( ( data = br.readLine() ) != null )
                {
                    str.append( data ).append( " " );
                }
            } catch ( Exception e )
            {
                
                str.append( e.toString() );
            }
            st = str.toString();
        } catch ( IOException es )
        {
            
            st = "";
        }
        return st;
    }

    /**
     * 新建目录
     *
     * @param folderPath 目录
     * @return 返回目录创建后的路径
     */
    public static String createFolder( String folderPath )
    {
        String txt = folderPath;
        try
        {
            java.io.File myFilePath = new java.io.File( txt );
            txt = folderPath;
            if ( !myFilePath.exists() )
            {
                myFilePath.mkdir();
            }
        } catch ( Exception e )
        {
           
        }
        return txt;
    }

    /**
     * 多级目录创建
     *
     * @param folderPath 准备要在本级目录下创建新目录的目录路径 例如 c:myf
     * @param paths      无限级目录参数，各级目录以单数线区分 例如 a|b|c
     * @return 返回创建文件后的路径 例如 c:myfac
     */
    public static String createFolders( String folderPath, String paths )
    {
        String txts = folderPath;
        try
        {
            String txt;
            txts = folderPath;
            StringTokenizer st = new StringTokenizer( paths, "|" );
            for ( int i = 0; st.hasMoreTokens(); i++ )
            {
                txt = st.nextToken().trim();
                if ( txts.lastIndexOf( "/" ) != -1 )
                {
                    txts = createFolder( txts + txt );
                } else
                {
                    txts = createFolder( txts + txt + "/" );
                }
            }
        } catch ( Exception e )
        {
           
        }
        return txts;
    }


    /**
     * 新建文件
     *
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @param fileContent     文本文件内容
     */
    public static void createFile( String filePathAndName, String fileContent )
    {

        FileWriter resultFile = null;
        PrintWriter myFile = null;
        try
        {
            String filePath = filePathAndName;
            filePath = filePath.toString();
            File myFilePath = new File( filePath );
            if ( !myFilePath.exists() )
            {
                myFilePath.createNewFile();
            }
            resultFile = new FileWriter( myFilePath );
            myFile = new PrintWriter( resultFile );
            String strContent = fileContent;
            myFile.println( strContent );
        } catch ( Exception e )
        {
           
        } finally
        {
            try
            {
                if ( resultFile != null )
                {
                    resultFile.close();
                }
            } catch ( IOException e )
            {
                
            }
            if ( myFile != null )
            {
                myFile.close();
            }
        }
    }

    /**
     * 删除文件
     *
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @return Boolean 成功删除返回true遭遇异常返回false
     */
    public static boolean delFile( String filePathAndName )
    {
        boolean bea = false;
        try
        {
            String filePath = filePathAndName;
            File myDelFile = new File( filePath );
            Runtime rt = Runtime.getRuntime();
            if ( myDelFile.exists() )
            {
                myDelFile.delete();
                return true;
    /*
                 rt.exec("cmd /c del "+filePathAndName);
                 bea = true;
    */
            } else
            {
                bea = false;
                message = ( filePathAndName + "删除文件操作出错" );
            }
        } catch ( Exception e )
        {
           
        }
        return bea;
    }


    /**
     * 删除文件夹
     *
     * @param folderPath 文件夹完整绝对路径
     */
    public static void delFolder( String folderPath )
    {
        try
        {
            delAllFile( folderPath ); //删除完里面所有内容
            String filePath = folderPath;
            filePath = filePath.toString();
            java.io.File myFilePath = new java.io.File( filePath );
            myFilePath.delete(); //删除空文件夹
        } catch ( Exception e )
        {
           
        }
    }


    /**
     * 删除指定文件夹下所有文件
     *
     * @param path 文件夹完整绝对路径
     */
    public static boolean delAllFile( String path )
    {
        boolean bea = false;
        File file = new File( path );
        if ( !file.exists() )
        {
            return bea;
        }
        if ( !file.isDirectory() )
        {
            return bea;
        }
        String[] tempList = file.list();
        File temp = null;
        for ( int i = 0; i < tempList.length; i++ )
        {
            if ( path.endsWith( File.separator ) )
            {
                temp = new File( path + tempList[ i ] );
            } else
            {
                temp = new File( path + File.separator + tempList[ i ] );
            }
            if ( temp.isFile() )
            {
                temp.delete();
            }
            if ( temp.isDirectory() )
            {
                delAllFile( path + "/" + tempList[ i ] );//先删除文件夹里面的文件
                delFolder( path + "/" + tempList[ i ] );//再删除空文件夹
                bea = true;
            }
        }
        return bea;
    }


    /**
     * 复制单个文件
     *
     * @param oldPathFile 准备复制的文件源
     * @param newPathFile 拷贝到新绝对路径带文件名
     */
    public static void copyFile( String oldPathFile, String newPathFile )
    {
        InputStream inStream = null;
        FileOutputStream fs = null;
        try
        {
            int bytesum = 0;
            int byteread = 0;
            File oldfile = new File( oldPathFile );
            if ( oldfile.exists() )
            { //文件存在时
                inStream = new FileInputStream( oldPathFile ); //读入原文件
                fs = new FileOutputStream( newPathFile );
                byte[] buffer = new byte[ 1444 ];
                while ( ( byteread = inStream.read( buffer ) ) != -1 )
                {
                    bytesum += byteread; //字节数 文件大小
                    //System.out.println(bytesum);
                    fs.write( buffer, 0, byteread );
                }
            }
        } catch ( Exception e )
        {
           
        } finally
        {
            try
            {
                if ( inStream != null )
                {
                    inStream.close();
                }
            } catch ( Exception ex )
            {
               
            }
            try
            {
                if ( fs != null )
                {
                    fs.close();
                }
            } catch ( Exception ex )
            {
               
            }
        }
    }


    /**
     * 复制整个文件夹的内容
     *
     * @param oldPath 准备拷贝的目录
     * @param newPath 指定绝对路径的新目录
     */
    public static void copyFolder( String oldPath, String newPath )
    {
        try
        {
            new File( newPath ).mkdirs(); //如果文件夹不存在 则建立新文件夹
            File a = new File( oldPath );
            String[] file = a.list();
            File temp = null;
            for ( int i = 0; i < file.length; i++ )
            {
                if ( oldPath.endsWith( File.separator ) )
                {
                    temp = new File( oldPath + file[ i ] );
                } else
                {
                    temp = new File( oldPath + File.separator + file[ i ] );
                }
                if ( temp.isFile() )
                {
                    FileInputStream input = new FileInputStream( temp );
                    FileOutputStream output = new FileOutputStream( newPath + "/" +
                            ( temp.getName() ).toString() );
                    byte[] b = new byte[ 1024 * 5 ];
                    int len;
                    while ( ( len = input.read( b ) ) != -1 )
                    {
                        output.write( b, 0, len );
                    }
                    output.flush();
                    output.close();
                    input.close();
                }
                if ( temp.isDirectory() )
                {//如果是子文件夹
                    copyFolder( oldPath + "/" + file[ i ], newPath + "/" + file[ i ] );
                }
            }
        } catch ( Exception e )
        {
           
        }
    }


    /**
     * 移动文件
     *
     * @param oldPath
     * @param newPath
     */
    public static void moveFile( String oldPath, String newPath )
    {
        copyFile( oldPath, newPath );
        delFile( oldPath );
    }


    /**
     * 移动目录
     *
     * @param oldPath
     * @param newPath
     */
    public static void moveFolder( String oldPath, String newPath )
    {
        copyFolder( oldPath, newPath );
        delFolder( oldPath );
    }

    public String getMessage()
    {
        return this.message;
    }
}
